
#Importing  the necessary libraries.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings("ignore", category=UserWarning)
%matplotlib inline


# mounting to drive
from google.colab import drive
drive.mount('/content/drive')

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).


# Reading a data file
df=pd.read_csv('/content/drive/MyDrive/Colab Notebooks/foodhub_order.csv')


# checking first five rows of the dataset
df.head()


#checking last five rows of the dataset
df.tail()


# Understanding the shape of data set---no.of rows vs no.columns
df.shape

(1898, 9)


# Analyzing the data types present in the data set
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   int64  
 1   customer_id            1898 non-null   int64  
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1898 non-null   object 
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: float64(1), int64(4), object(4)
memory usage: 133.6+ KB


# changing order_id and customer_id datatype
df['order_id'] = df['order_id'].astype(str)
df['customer_id'] = df['customer_id'].astype(str)
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   object 
 1   customer_id            1898 non-null   object 
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1898 non-null   object 
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: float64(1), int64(2), object(6)
memory usage: 133.6+ KB


# changing 'rating' entries 'Not given' to nan and change its datatype
#Int(64)--pandas-specific nullable integer type that can handle missing values (NaNs).
df['rating'] = df['rating'].replace('Not given', np.nan)
df['rating'] = df['rating'].astype('Int64')
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   object 
 1   customer_id            1898 non-null   object 
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1162 non-null   Int64  
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: Int64(1), float64(1), int64(2), object(5)
memory usage: 135.4+ KB


# New info of datatype
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   object 
 1   customer_id            1898 non-null   object 
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1162 non-null   Int64  
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: Int64(1), float64(1), int64(2), object(5)
memory usage: 135.4+ KB


# checking if any duplicate data is present in the dataset
df.duplicated().sum()

0


# checking if missing data is present with in the datset
df.isnull().sum()

order_id                   0
customer_id                0
restaurant_name            0
cuisine_type               0
cost_of_the_order          0
day_of_the_week            0
rating                   736
food_preparation_time      0
delivery_time              0
dtype: int64


# Checking the percentage of data missing in the 'rating' column.
(df['rating'].isnull().sum()/len(df))*100

38.77766069546891


#unique values which are present in 'rating' column
df['rating'].unique()

<IntegerArray>
[<NA>, 5, 3, 4]
Length: 4, dtype: Int64


# Group by 'cuisine_type'
grouped = df.groupby('cuisine_type')

# Function to calculate mode
def mode(substitute):
    if not substitute.mode().empty:
        return substitute.mode().iloc[0]
    else:
        return substitute


# Apply the function to each group and create a Series with the mode values
rating_cuisine_with_mode = grouped['rating'].apply(mode)

# Map the mode values back to the original dataframe
rating_cuisine_with_mode = rating_cuisine_with_mode.reindex(df['cuisine_type']).values

# Fill the NaN values in 'rating' with  mode values from the group
df['rating'] = df['rating'].combine_first(pd.Series(rating_cuisine_with_mode))


# Verifying the 'rating' column after filling with mode values
df['rating'].isnull().sum()

0


# Verifying the first 5 entries which had null values earlier
df.head()


df['rating'].describe()

count      1898.0
mean     4.584299
std      0.665836
min           3.0
25%           4.0
50%           5.0
75%           5.0
max           5.0
Name: rating, dtype: Float64


# checking the statistical summary of the dataset
# T - Transpose for easy readability
df.describe().T


df['food_preparation_time'].describe()

count    1898.000000
mean       27.371970
std         4.632481
min        20.000000
25%        23.000000
50%        27.000000
75%        31.000000
max        35.000000
Name: food_preparation_time, dtype: float64


minimum_time=df['food_preparation_time'].min()
average_time=round(df['food_preparation_time'].mean())
maximum_time=df['food_preparation_time'].max()
print('Time Taken For Food Preparation')

# minum time taken for preparation of food
print("Minimum :",minimum_time,"minutes")

# average time taken for preparation of food
print("Average :",average_time,"minutes")

# maximum time taken for preparation of food
print("Maximum :",maximum_time,"minutes")

Time Taken For Food Preparation
Minimum : 20 minutes
Average : 27 minutes
Maximum : 35 minutes


# Creating a column 'total_order_time'
df['customer_wait_time'] = df['food_preparation_time'] + df['delivery_time']
df.head()


df['customer_wait_time'].describe()

count    1898.000000
mean       51.533720
std         6.833603
min        35.000000
25%        47.000000
50%        52.000000
75%        56.000000
max        68.000000
Name: customer_wait_time, dtype: float64


# histogram for rating - Showing the distribution of the datapoints
plt.figure(figsize=(7, 5))  # size of the plot to display
sns.histplot(data=df, x="rating",kde=True)  # kde=True for kernel density estimate
plt.title('Distribution of Rating') #heading of the plot
plt.xlabel('Rating') # x-axis label
plt.show()


#  countplot for rating - showing the count of individual rating
plt.figure(figsize=(7, 5)) # size of the plot to display
sns.countplot(x='rating', data=df)
plt.title('Distribution count of Rating') # heading of the plot
plt.xlabel('Rating') # x-axis label
plt.show()


# visualizing 'cost of the order' using Boxplot
plt.figure(figsize=(7, 5)) #size of the plot displayed
sns.boxplot(data=df, x="cost_of_the_order")
plt.title('Distribution of order cost') # heading of the plot
plt.xlabel('Cost of order ($) ') # x-axis label
plt.show()


# violin plot for cost of order for more detailed view
plt.figure(figsize=(7, 5)) #size of the plot displayed
sns.violinplot(data=df, x="cost_of_the_order")
plt.title('Distribution of order cost') # heading of the plot
plt.xlabel('Cost of order in $ ')  # x-axis label
plt.show()


# analysing food preparation time with countplot

sns.countplot(data=df,x='food_preparation_time');
plt.title('Distribution count of food preparation time') # heading of the plot
plt.xlabel('food_preparation_time in minutes') # x-axis label
plt.show()


# analysing  food preparation time with boxplot

sns.boxplot(data=df,x='food_preparation_time');
plt.title('Distribution of food preparation time') # heading of the plot
plt.xlabel('food_preparation_time in minutes');


# visualizing delivery time with countplot
plt.figure(figsize=(7, 5)) #size of the plot displayed
sns.countplot(data=df,x='delivery_time');
plt.title('Distribution count of delivery time') # heading of the plot
plt.xlabel('delivery_time in minutes') # x-axis label
plt.show()


# visualizing the delivery time datapoint summary with boxplot
sns.boxplot(data=df,x='delivery_time')
plt.title('Distribution of delivery time') # heading of the plot
plt.xlabel('delivery_time in minutes') #x-axis label
plt.show()


#visualising total time a customer waits to receive order
sns.countplot(data=df,x='customer_wait_time');
plt.title('Distribution count of customer wait time') # heading of the plot
plt.xlabel('customer_wait_time in minutes'); # x-axis label
plt.xticks(rotation=90)
plt.show()


# visualizing the distribution of data summary
sns.boxplot(data=df,x='customer_wait_time');
plt.xlabel('customer_wait_time in minutes');
plt.title('Distribution of customer wait time') # heading of the plot
plt.xticks(rotation=90)
plt.show()


# Total no.of unique ids alotted to the customers
df['customer_id'].nunique()

1200


# No.of orders placed with each customer_id
df['customer_id'].value_counts()

customer_id
52832     13
47440     10
83287      9
250494     8
259341     7
          ..
385426     1
254913     1
289597     1
74412      1
397537     1
Name: count, Length: 1200, dtype: int64


df['order_id'].nunique()

1898


# analyzing cuisine type  with countplot

plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.countplot(x="cuisine_type", data=df)
plt.title("Distribution count of orders made for particular cuisine") # heading of the plot
plt.xlabel("Type of cuisine")   #x-axis label
plt.xticks(rotation=90)
plt.show()


#  analysis of categorical variable -day_of_the_week with countplot
plt.figure(figsize=(8, 5)) #size of the plot displayed
sns.countplot(x="day_of_the_week", data=df, color='aqua')
plt.title("Frequency of orders made for day_of_the_week") # heading of the plot
plt.xlabel("Weekday vs Weekend")   #x-axis label
plt.ylabel("Count of Orders")  #y-axis label
plt.xticks(rotation=90)
plt.show()


#  percentage of orders on weekends

weekend_orders = df[df['day_of_the_week']=='Weekend']
total_orders = len(df)
percentage_weekend_orders = (len(weekend_orders) / total_orders) * 100
print("Percentage of orders on weekends:" ,round(percentage_weekend_orders),"%")

#  percentage of orders on weekdays

weekday_orders = df[df['day_of_the_week']=='Weekday']
total_orders = len(df)
percentage_weekday_orders = (len(weekday_orders) / total_orders) * 100
print("Percentage of orders on weekdays:" ,round(percentage_weekday_orders),"%")

Percentage of orders on weekends: 71 %
Percentage of orders on weekdays: 29 %


# number of unique values in the 'restaurant_name' column of the DataFrame
df['restaurant_name'].nunique()

178


# count of how many times each value occurs.
df['restaurant_name'].value_counts()

restaurant_name
Shake Shack                  219
The Meatball Shop            132
Blue Ribbon Sushi            119
Blue Ribbon Fried Chicken     96
Parm                          68
                            ... 
Sushi Choshi                   1
Dos Caminos Soho               1
La Follia                      1
Philippe Chow                  1
'wichcraft                     1
Name: count, Length: 178, dtype: int64


# visualizing the count of orders made in restaurant_name column
plt.figure(figsize=(70, 30)) #size of the plot displayed
sns.countplot(x="restaurant_name", data=df)
plt.title(" Count of orders made in each restaurant") # heading of the plot
plt.xlabel("Restaurant Name")   #x-axis label
plt.ylabel("Count") #y-label
plt.xticks(rotation=90)
plt.show()


#the top 5 restaurants in terms of the number of orders received
df['restaurant_name'].value_counts().head(5)

restaurant_name
Shake Shack                  219
The Meatball Shop            132
Blue Ribbon Sushi            119
Blue Ribbon Fried Chicken     96
Parm                          68
Name: count, dtype: int64


# visualizing which cuisine is popular on weekend(saturday and sunday)
sns.countplot(x='cuisine_type',data=df,hue='day_of_the_week')
plt.xticks(rotation=90)  # rotating the x-axis labels for better readability
plt.title('Popularity of Cuisines on Weekends vs Weekdays') # heading of the plot
plt.xlabel('Cuisine Type') # x-axis label
plt.ylabel('Count of Orders') # y-axis label
plt.show()


# Percentage of orders with cost_of_the_order more than 20$

total_no_of_orders = len(df) #length of the df
orders_above_20 = len(df[df['cost_of_the_order'] > 20]) #length of orders with cost > 20$
percentage = (orders_above_20/ total_no_of_orders) * 100 # calculating percentage of orders with cost > 20$
print('Percentage of orders with cost more than 20$ = ', round(percentage,2),"%")

Percentage of orders with cost more than 20$ =  29.24 %


# checking the average delivery time taken
mean_delivery_time=df['delivery_time'].mean()
print(round( mean_delivery_time ,2 ))

24.16


# Finding the Ids of top-3 customers and number of orders placed by them
customer_order = df['customer_id'].value_counts() # count of orders for each customer
top_3_customers=customer_order.head(3) # top 3 customers
print(top_3_customers)

customer_id
52832    13
47440    10
83287     9
Name: count, dtype: int64


# creating 2 columns for better display and readability
top_customers_for_discount = top_3_customers.reset_index() # converting the series to dataframe
top_customers_for_discount.columns = ['customer_id', 'order_count'] # renaming the columns
top_customers_for_discount


# Creating a heatmap of the numerical variables
plt.figure(figsize=(10, 8))
sns.heatmap(df[['cost_of_the_order', 'food_preparation_time','delivery_time', 'rating']].corr(), annot=True, cmap='coolwarm')
plt.title('Heatmap of Numerical Variables')
plt.show()


# Analyzing the relation between cost of order and  delivery time
plt.figure(figsize=(7, 5)) #size of the plot displayed
sns.regplot(x='cost_of_the_order', y='delivery_time', data=df)
plt.title('Cost of order vs Delivery time') # heading of the plot
plt.xlabel('Cost of order') # x-axis label
plt.ylabel('Delivery time') # y-axis label
plt.grid(True)
plt.show()


# visualizing boxplot of cost of order and customer waiting time
plt.figure(figsize=(15, 7)) #size of the plot displayed
sns.boxplot(x="customer_wait_time", y="cost_of_the_order", data=df)
plt.title("Cost of Order vs Customer Wait Time") # heading of the plot
plt.xlabel("Customer Wait Time") # x-axis label
plt.xticks(rotation=90)
plt.ylabel("Cost of Order") # y-axis label
plt.show()


# analysizing the orders each reasturant gets on weekdays and weekends
plt.figure(figsize=(25, 5)) #size of the plot displayed
sns.countplot(x='restaurant_name',data=df,hue='day_of_the_week')
plt.xticks(rotation=90)  # rotating the x-axis labels for better readability
plt.title('Popularity of Restaurant on Weekends vs Weekdays') # heading of the plot
plt.xlabel('Restaurant Names') # x-axis label
plt.ylabel('Count of Orders') #number of orders for each restaurant
plt.show()


# Analysizing cuisine preference depending of day_of_the_week
sns.countplot(x='cuisine_type',data=df,hue='day_of_the_week')
plt.xticks(rotation=90)  # rotating the x-axis labels for better readability
plt.title('Preference of Cuisines  on Weekends vs Weekdays') # heading of the plot
plt.xlabel('Cuisine Type') #x-axis label
plt.ylabel('Count of Orders') #y-label
plt.show()


# Visualizing boxplot of cost of order and cuisine type

plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.boxplot(x="cuisine_type", y="cost_of_the_order", data=df)
plt.title("Cost of Order vs Cuisine Type")  # heading of the plot
plt.xlabel("Cuisine Type") # x-axis label
plt.xticks(rotation=90)
plt.ylabel("Cost of Order in $") # y-axis label
plt.show()


# Visualizing barplot of rating and cuisine type

plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.barplot(x="cuisine_type", y="rating", data=df)
plt.title("Rating Vs Cuisine Type")  # heading of the plot
plt.xlabel("Cuisine Type") # x-axis label
plt.xticks(rotation=90)
plt.ylabel("Rating") # y-axis label
plt.show()


# visualizing Boxplot of customer_wait_time vs. day_of_the_week.
plt.figure(figsize=(8, 5)) #size of the plot displayed
sns.boxplot(x="day_of_the_week", y="customer_wait_time", data=df)
plt.title("Customer Wait Time vs Day of the Week")  # heading of the plot
plt.xlabel("Day of the Week") # x-axis label
plt.xticks(rotation=90)
plt.ylabel("Customer Wait Time") # y-axis label
plt.show()


# visualizing Boxplot of food_preparation_time vs. cuisine_type.
plt.figure(figsize=(8, 5)) #size of the plot displayed
sns.boxplot(x="cuisine_type", y="food_preparation_time", data=df)
plt.title("Food Preparation Time vs Cuisine Type")  # heading of the plot
plt.xlabel("Cuisine Type") # x-axis label
plt.xticks(rotation=90)
plt.ylabel("Food Preparation Time") # y-axis label
plt.show()


# visualizing boxplot of cuisine and customer waiting time
plt.figure(figsize=(15, 7)) #size of the plot displayed
sns.boxplot(y="customer_wait_time", x="cuisine_type", data=df)
plt.title("Cuisine Type vs Customer Wait Time") # heading of the plot
plt.ylabel("Customer Wait Time") # x-axis label
plt.xticks(rotation=90)
plt.xlabel("cuisine_type") # y-axis label
plt.show()


# visualizing boxplot of food_preparation_time and day_of_the_week
plt.figure(figsize=(8,5)) #size of the plot displayed
sns.boxplot(y="day_of_the_week", x="food_preparation_time", data=df)
plt.title("food preparation time vs day_of_the_week") # heading of the plot
plt.ylabel("day of the week") # y-axis label
plt.xticks(rotation=90)
plt.xlabel("food preparation time") # x-axis label
plt.show()


# visualizing boxplot of delivery_time and cuisine type
plt.figure(figsize=(8,5)) #size of the plot displayed
sns.boxplot(y="delivery_time", x="cuisine_type", data=df)
plt.title("Delivery time vs Cuisine type") # heading of the plot
plt.ylabel("delivery_time") # y-axis label
plt.xticks(rotation=90)
plt.xlabel("cuisine_type") # x-axis label
plt.show()


# visualizing boxplot of delivery_time and cuisine type
plt.figure(figsize=(8,4)) #size of the plot displayed
sns.boxplot(y="delivery_time", x="day_of_the_week", data=df)
plt.title("Delivery time vs Day of the Week") # heading of the plot
plt.ylabel("delivery_time") # y-axis label
plt.xticks(rotation=90)
plt.xlabel("Day of the week") # x-axis label
plt.show()


# Analyzing using scatterplot
plt.figure(figsize=(30, 10)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="customer_wait_time", hue="cuisine_type", data=df)
plt.title("Cost of the Order vs Customer Wait Time vs Cuisine Type") # heading of the plot
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("Customer Wait Time") # y-axis label
plt.legend(title="Cuisine Type")
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.grid(True)
plt.show()


# As from method of sampling suggested on COMMUNITY BLOCK of dashboard
# Making a Sample DataFrame for understanding the plot from above which is clustered
np.random.seed(0)  #random numbers generated that are reproducible
data = {"cost_of_the_order": np.random.randint(5, 35, 800), #sample size of 800
    "customer_wait_time": np.random.randint(30, 70, 800),
    "cuisine_type": np.random.choice(['American','Japanese','Italian','Chinese','Mexican' ], 800)} #considering top 5 restaurants
sample_df = pd.DataFrame(data) # new sameple dataframe

plt.figure(figsize=(12, 6)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="customer_wait_time", hue="cuisine_type", data=sample_df,) #making a plot for sample for sample
plt.title("Cost of the Order vs Customer Wait Time vs Cuisine Type")
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("Customer Wait Time") # y-axis label
plt.legend(title="Cuisine Type") # legend box title
plt.legend(bbox_to_anchor=(1, 1), loc='upper left') # adjusting the legend box out of plot for readability
plt.grid(True) #grid view for easy understanding of placement of datapoints
plt.show()


# Analyzing using scatterplot
plt.figure(figsize=(30, 10)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="rating", hue="cuisine_type", data=df)
plt.title("Cost of the Order vs Rating vs Cuisine Type") # heading of the plot
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("rating") # y-axis label
plt.legend(title="cuisine type")
plt.xticks(rotation=90)
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.grid(True)
plt.show()


#Analyzing using boxplot
plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.scatterplot(x="food_preparation_time", y="cost_of_the_order", hue="cuisine_type", data=df)
plt.title("food_preparation_time vs cost_of_the_order vs cuisine_type") # heading of the plot
plt.xlabel("food_preparation_time") # x-axis label
plt.ylabel("cost_of_the_order") # y-axis label
plt.legend(bbox_to_anchor=(1, 1), loc='upper left') # adjusting the legend box out of plot for readability
plt.grid(True)
plt.show()


# As from method of sampling suggested on COMMUNITY BLOCK of dashboard
# Making a Sample DataFrame for understanding the plot from above which is clustered
np.random.seed(0)  #random numbers generated that are reproducible
data = {"cost_of_the_order": np.random.randint(5, 35, 500), #sample size of 500
    "food_preparation_time": np.random.randint(30, 70, 500),
    "cuisine_type": np.random.choice(['American','Japanese','Italian','Chinese','Mexican' ], 500)} #considering top 5 restaurants
sample_df = pd.DataFrame(data) # new sameple dataframe

plt.figure(figsize=(20, 8)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="food_preparation_time", hue="cuisine_type", data=sample_df) #making a plot for sample for sample
plt.title("Cost of the Order vs food_preparation Time vs Cuisine Type")
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("food_preparation Time") # y-axis label
plt.legend(title="Cuisine Type") # legend box title
plt.legend(bbox_to_anchor=(1, 1), loc='upper left') # adjusting the legend box out of plot for readability
plt.grid(True) #grid view for easy understanding of placement of datapoints
plt.show()


# Analyzing using scatterplot
plt.figure(figsize=(30, 10)) #size of the plot displayed
sns.scatterplot(x="food_preparation_time", y="rating", hue="cuisine_type", data=df)
plt.title("food_preparation_time vs Rating vs Cuisine Type") # heading of the plot
plt.xlabel("food_preparation_timer") # x-axis label
plt.ylabel("rating") # y-axis label
plt.legend(title="cuisine type")
plt.xticks(rotation=90)
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.grid(True)
plt.show()


# Analyzing using scatterplot
plt.figure(figsize=(30, 10)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="food_preparation_time", hue="restaurant_name", data=df)
plt.title("Cost of the Order vs food_preparation_time vs restaurant_name") # heading of the plot
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("food_preparation_time") # y-axis label
plt.legend(title="restaurant_name")
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.grid(True)
plt.show()


df['restaurant_name'].value_counts().head(5)

restaurant_name
Shake Shack                  219
The Meatball Shop            132
Blue Ribbon Sushi            119
Blue Ribbon Fried Chicken     96
Parm                          68
Name: count, dtype: int64


# As from method of sampling suggested on COMMUNITY BLOCK of dashboard
# Making a Sample DataFrame for understanding the plot from above which is clustered
np.random.seed(0)  #random numbers generated that are reproducible
data = {"cost_of_the_order": np.random.randint(5, 35, 100), #sample size of 100
    "food_preparation_time": np.random.randint(30, 70, 100),
    "restaurant_name": np.random.choice(['Shake Shack','The Meatball Shop','Blue Ribbon Sushi','Blue Ribbon Fried Chicken','Parm' ], 100)} #considering top 5 restaurants
sample_df = pd.DataFrame(data) # new sameple dataframe

plt.figure(figsize=(12, 6)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="food_preparation_time", hue="restaurant_name", data=sample_df,) #making a plot for sample for sample
plt.title("Cost of the Order vs food_preparation_time vs Restaurant Name")
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("Food Preparation Time") # y-axis label
plt.legend(title="restaurant_name") # legend box title
plt.legend(bbox_to_anchor=(1, 1), loc='upper left') # adjusting the legend box out of plot for readability
plt.grid(True) #grid view for easy understanding of placement of datapoints
plt.show()


# Analyzing using scatterplot
plt.figure(figsize=(30, 10)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="delivery_time", hue="restaurant_name", data=df)
plt.title("Cost of the Order vs delivery_time vs restaurant_name") # heading of the plot
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("delivery_time") # y-axis label
plt.legend(title="restaurant_name")
plt.legend(bbox_to_anchor=(1, 1), loc='upper left')
plt.grid(True)
plt.show()


# As from method of sampling suggested on COMMUNITY BLOCK of dashboard
# Making a Sample DataFrame for understanding the plot from above which is clustered
np.random.seed(0)  #random numbers generated that are reproducible
data = {"cost_of_the_order": np.random.randint(5, 35, 100), #sample size of 100
    "delivery_time": np.random.randint(30, 70, 100),
    "restaurant_name": np.random.choice(['Shake Shack','The Meatball Shop','Blue Ribbon Sushi','Blue Ribbon Fried Chicken','Parm' ], 100)} #considering top 5 restaurants
sample_df = pd.DataFrame(data) # new sameple dataframe

plt.figure(figsize=(12, 6)) #size of the plot displayed
sns.scatterplot(x="cost_of_the_order", y="delivery_time", hue="restaurant_name", data=sample_df,) #making a plot for sample for sample
plt.title("Cost of the Order vs delivery_time vs Restaurant Name")
plt.xlabel("Cost of the Order") # x-axis label
plt.ylabel("Delivery Time") # y-axis label
plt.legend(title="restaurant_name") # legend box title
plt.legend(bbox_to_anchor=(1, 1), loc='upper left') # adjusting the legend box out of plot for readability
plt.grid(True) #grid view for easy understanding of placement of datapoints
plt.show()


#Analyzing using boxplot
plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.catplot(x="rating", y="food_preparation_time", hue="day_of_the_week", data=df,kind='box')
plt.title("Rating vs Food Preparation Time vs Day of the Week") # heading of the plot
plt.xlabel("Rating") # x-axis label
plt.ylabel("Food preparation Time") # y-axis label
plt.show()

<Figure size 1000x500 with 0 Axes>


#Analyzing using boxplot
plt.figure(figsize=(10, 5)) #size of the plot displayed
sns.catplot(x="rating", y="delivery_time", hue="day_of_the_week", data=df,kind='box')
plt.title("Rating vs Delivery Time vs Day of the Week") # heading of the plot
plt.xlabel("Rating") # x-axis label
plt.ylabel("Delivery Time") # y-axis label
plt.show()

<Figure size 1000x500 with 0 Axes>


# Group by restaurant_name and calculate the count and average of the ratings
grouped = df.groupby('restaurant_name').agg(count=('rating', 'count'),average=('rating', 'mean')).reset_index()
eligible_restaurants = grouped[(grouped['count'] > 50) &(grouped['average'] > 4)] # Filter based on the given conditons

print(eligible_restaurants)

               restaurant_name  count   average
20   Blue Ribbon Fried Chicken     96  4.552083
21           Blue Ribbon Sushi    119  4.521008
109                       Parm     68       4.5
121           RedFarm Broadway     59  4.474576
122             RedFarm Hudson     55  4.490909
136                Shake Shack    219  4.561644
153          The Meatball Shop    132  4.689394


# calculating the commision charged by the company
def calculate_net_revenue(cost_of_the_order):
    if cost_of_the_order > 20:
        return cost_of_the_order * 0.25  # 25% on orders cost more than 20 $
    if cost_of_the_order > 5:
        return cost_of_the_order * 0.15 # 15% on orders cost more than 5 $

# calculating the net revenue
df['net_revenue'] = df['cost_of_the_order'].apply(calculate_net_revenue)
print('Revenue Generated By The Company :',df['net_revenue'].sum(),"$")


#calculating the total revenue which is sum of commision charged by the company as well as restaurant bill
# Total amount paid by the customer for these orders (ignoring taxes and other charges if any)
def calculate_total_revenue(cost_of_the_order):
    if cost_of_the_order > 20:
        return cost_of_the_order * 0.25 +cost_of_the_order # 25% on orders cost more than 20 $
    if cost_of_the_order > 5:
        return cost_of_the_order * 0.15 +cost_of_the_order  # 15% on orders cost more than 5 $

# calculating the total revenue
df['total_revenue'] = df['cost_of_the_order'].apply(calculate_total_revenue)
print('Total Amount Paid By The Customers :',df['total_revenue'].sum(),"$")

Revenue Generated By The Company : 6166.303 $
Total Amount Paid By The Customers : 37438.383 $


#analysing total delivery time
# customer_wait_time column = food preparation time + delivery time taken
number_of_orders_abv_60_minutes = len(df[df['customer_wait_time'] > 60])
percentage_orders_abv_60_minutes = (number_of_orders_abv_60_minutes / len(df)) * 100
print("Percentage of orders that take more than 60 minutes to get delivered:",round(percentage_orders_abv_60_minutes,2),"%")

Percentage of orders that take more than 60 minutes to get delivered: 10.54 %


df['day_of_the_week'].value_counts()

day_of_the_week
Weekend    1351
Weekday     547
Name: count, dtype: int64


# mean delivery time on weekend
mean_delivery_time_weekend = df[df['day_of_the_week'] == 'Weekend']['delivery_time'].mean()
print("Mean delivery time on weekend:", mean_delivery_time_weekend, "minutes")

# mean delivery time on weekday
mean_delivery_time_weekday = df[df['day_of_the_week'] == 'Weekday']['delivery_time'].mean()
print("Mean delivery time on weekday:", mean_delivery_time_weekday, "minutes")

# variation in mean delivery time on weekdays ,weekends
mean_variation = -mean_delivery_time_weekend + mean_delivery_time_weekday
print("Mean delivery time variation:", mean_variation, "minutes")

Mean delivery time on weekend: 22.4700222057735 minutes
Mean delivery time on weekday: 28.340036563071298 minutes
Mean delivery time variation: 5.870014357297798 minutes


#Importing  the necessary libraries.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings("ignore", category=UserWarning)
%matplotlib inline

# mounted to drive
from google.colab import drive
drive.mount('/content/drive')
# Reading a data file
df=pd.read_csv('/content/drive/MyDrive/Colab Notebooks/foodhub_order.csv')

df.info() # gives info of the dataframe
data= df.copy() # making a copy of the dataframe

Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1898 entries, 0 to 1897
Data columns (total 9 columns):
 #   Column                 Non-Null Count  Dtype  
---  ------                 --------------  -----  
 0   order_id               1898 non-null   int64  
 1   customer_id            1898 non-null   int64  
 2   restaurant_name        1898 non-null   object 
 3   cuisine_type           1898 non-null   object 
 4   cost_of_the_order      1898 non-null   float64
 5   day_of_the_week        1898 non-null   object 
 6   rating                 1898 non-null   object 
 7   food_preparation_time  1898 non-null   int64  
 8   delivery_time          1898 non-null   int64  
dtypes: float64(1), int64(4), object(4)
memory usage: 133.6+ KB


# Drop rows where the rating is 'Not given'
data = data[data['rating'] != 'Not given']

# Convert 'rating' to numeric
data['rating'] = pd.to_numeric(data['rating'])

# Group by restaurant name and calculate the count and mean of ratings
restaurant_ratings = data.groupby('restaurant_name').agg(
    rating_count=('rating', 'count'),
    average_rating=('rating', 'mean')
).reset_index()

# Filter the restaurants fulfilling the criteria
filtered_restaurants = restaurant_ratings[(restaurant_ratings['rating_count'] > 50) & (restaurant_ratings['average_rating'] > 4)]

print(filtered_restaurants)

               restaurant_name  rating_count  average_rating
16   Blue Ribbon Fried Chicken            64        4.328125
17           Blue Ribbon Sushi            73        4.219178
117                Shake Shack           133        4.278195
132          The Meatball Shop            84        4.511905

	order_id	customer_id	restaurant_name	cuisine_type	cost_of_the_order	day_of_the_week	rating	food_preparation_time	delivery_time
0	1477147	337525	Hangawi	Korean	30.75	Weekend	Not given	25	20
1	1477685	358141	Blue Ribbon Sushi Izakaya	Japanese	12.08	Weekend	Not given	25	23
2	1477070	66393	Cafe Habana	Mexican	12.23	Weekday	5	23	28
3	1477334	106968	Blue Ribbon Fried Chicken	American	29.20	Weekend	3	25	15
4	1478249	76942	Dirty Bird to Go	American	11.59	Weekday	4	25	24

	order_id	customer_id	restaurant_name	cuisine_type	cost_of_the_order	day_of_the_week	rating	food_preparation_time	delivery_time
1893	1476701	292602	Chipotle Mexican Grill $1.99 Delivery	Mexican	22.31	Weekend	5	31	17
1894	1477421	397537	The Smile	American	12.18	Weekend	5	31	19
1895	1477819	35309	Blue Ribbon Sushi	Japanese	25.22	Weekday	Not given	31	24
1896	1477513	64151	Jack's Wife Freda	Mediterranean	12.18	Weekday	5	23	31
1897	1478056	120353	Blue Ribbon Sushi	Japanese	19.45	Weekend	Not given	28	24

	count	mean	std	min	25%	50%	75%	max
cost_of_the_order	1898.0	16.498851	7.483812	4.47	12.08	14.14	22.2975	35.41
rating	1898.0	4.584299	0.665836	3.0	4.0	5.0	5.0	5.0
food_preparation_time	1898.0	27.37197	4.632481	20.0	23.0	27.0	31.0	35.0
delivery_time	1898.0	24.161749	4.972637	15.0	20.0	25.0	28.0	33.0

Problem Statement¶

Data Dictionary¶

Importing The Libraries¶

Importing The Datafile¶

Head and tail of the dataset¶

Question 1:¶

How many rows and columns are present in the data? [0.5 mark]¶

Question 2:¶

Changing Datatype¶

Question 3:¶

Duplicate Data¶

Missing values¶

Question 5:¶

Percentage of missing values¶

Missing Value treatmeant -- 'rating'¶

Question 4:¶

Statistical Summary¶

Food_Preparation_Time -- Minimum ,Maximum ,Average¶

Creating a new column "Customer Wait Time"¶

Exploratory Data Analysis (EDA):¶

Univariate Analysis¶

Question 6:¶

Univariate Numerical Variables¶

> Rating¶

> Cost of the order¶

> Food preparation time¶

> Deliver time¶

* The pot shows the mode with highest bar for the delivery time taken that is 24 minutes.¶

> Customer wait time¶

Univariate Categorical Variables¶

> customer_id¶

> order_id¶

> cuisine_type¶

> day_of_the_week¶

> restaurant_name¶

Question 7:¶

Question 8:¶

Question 9:¶

Question 10:¶

Question 11:¶

Multivariate Analysis¶

Question 12:¶

Bivariate numerical analysis¶

Heatmap of Numerical Variables¶

Itemization (cost of order vs delivery time)¶

customer_wait_time---Vs---cost_of_the_order¶

Bivariate categorical analysis¶

restaurant_name---Vs---day_of_the_week¶

cuisine_type---Vs---day_of_the_week¶

Bivariate analysis between Numerical variables and categorical varaiables¶

cost_of_the_order---VS---cuisine_type¶

rating---Vs---cuisine_type¶

customer_wait_time---Vs---day_of_the_week.¶

food_preparation_time---Vs---cuisine_type.¶

cuisine_type---Vs--- customer waiting time¶

food_preparation_time---Vs---day_of_week¶

cuisine_type---Vs---delivery_time¶

day_of_the_week---Vs---delivery_time¶

Multivariate analysis¶

1. cost_of_the_order vs. customer_wait_time vs. cuisine_type¶

2. rating vs. cost_of_the_order vs. cuisine_type¶

3. food_preparation_time vs. cost_of_the_order vs. cuisine_type¶

4. rating vs. food_preparation_time vs. cuisine_type¶

5. cost_of_the_order vs. food_preparation_time vs. restaurant_name¶

6. delivery_time vs. cost_of_the_order vs. restaurant_name¶

7. rating vs. food_preparation_time vs. day_of_the_week¶

8. rating vs. delivery_time vs. day_of_the_week¶

Question 13:¶

Question 14:¶

Question 15:¶

Question 16:¶

Question 17:¶

Conclusions¶

Recommendations¶

Question:13 [CASE WHERE RATINGS IS DIFFERENTLY TREATED]¶

1. `cost_of_the_order` vs. `customer_wait_time` vs. `cuisine_type`¶

2. `rating` vs. `cost_of_the_order` vs. `cuisine_type`¶

3. `food_preparation_time` vs. `cost_of_the_order` vs. `cuisine_type`¶

4. `rating` vs. `food_preparation_time` vs. `cuisine_type`¶

5. `cost_of_the_order` vs. `food_preparation_time` vs. `restaurant_name`¶

6. `delivery_time` vs. `cost_of_the_order` vs. `restaurant_name`¶

7. `rating` vs. `food_preparation_time` vs. `day_of_the_week`¶

8. `rating` vs. `delivery_time` vs. `day_of_the_week`¶